// 引入云数据库实例
const db = wx.cloud.database(); // 获取云数据库对象
// 引入数据库操作符
const _ = db.command; // 数据库操作符
// 引入工具函数，用于日期处理
const util = require('../../../utils/util.js'); // 引入日期处理工具

// 定义页面对象
Page({
  // 页面的初始数据
  data: {
    userInfo: null,        // 当前登录用户信息
    classList: [],         // 班级列表数据
    currentClassId: null,  // 当前选中的班级ID
    studentsInClass: [],   // 当前班级的学生列表
    currentStudentId: null, // 当前选中的学生ID
    currentStudentName: '', // 当前选中学生的姓名
    logs: [],              // 谈话日志列表
    
    // 加载状态标识符
    isLoadingClasses: true,    // 是否正在加载班级列表
    isLoadingStudents: false,  // 是否正在加载学生列表
    isLoadingLogs: false,      // 是否正在加载日志
    
    // 添加日志相关数据
    showAddLogModal: false,  // 是否显示添加日志的模态框
    newLogContent: '',       // 新日志的内容
    isSubmitting: false,     // 是否正在提交日志
    
    // 下拉选择器索引值
    classPickerIndex: 0,     // 班级选择器的当前索引
    studentPickerIndex: 0    // 学生选择器的当前索引
  },

  // 页面加载时执行
  onLoad() {
    // 加载用户信息和管理的班级
    this.loadUserInfoAndClasses();
  },

  // 加载用户信息和班级列表
  async loadUserInfoAndClasses() {
    // 设置加载状态
    this.setData({ isLoadingClasses: true });
    // 从本地存储获取用户信息
    const userInfo = wx.getStorageSync('userInfo');
    
    // 验证用户身份是否为辅导员
    if (!userInfo || userInfo.role !== 'teacher') {
      wx.showToast({ title: '用户未登录或非辅导员', icon: 'none' });
      this.setData({ isLoadingClasses: false });
      return;
    }
    
    // 检查用户信息是否包含openid
    if (!userInfo._openid) {
      wx.showToast({ title: '用户信息不完整，无法查询', icon: 'none' });
      this.setData({ isLoadingClasses: false });
      return;
    }
    
    // 保存用户信息到页面数据中
    this.setData({ userInfo }); // 保存一份 userInfo 供其他地方使用

    try {
      // 从云端查询辅导员管理的班级列表
      console.log(`查询 users 集合，条件: _openid=${userInfo._openid}`);
      const userRes = await db.collection('users').where({
        _openid: userInfo._openid
      }).get(); // 获取完整用户数据

      console.log("从云端获取到用户数据:", userRes.data);

      // 获取所有用户文档中的classes字段并合并去重
      let allClasses = [];
      userRes.data.forEach(user => {
        if (user.classes && Array.isArray(user.classes)) {
          allClasses = [...allClasses, ...user.classes];
        }
      });
      
      // 数组去重，获取唯一班级ID列表
      const managedClassIds = [...new Set(allClasses)];
      console.log("合并后的班级列表:", managedClassIds);

      // 如果有管理的班级，则构建显示列表
      if (managedClassIds.length > 0) {
        // 构建用于显示的班级列表数据
        const classListForDisplay = managedClassIds.map(id => ({
          _id: id,
          name: `班级 ${id}` 
        }));
        console.log("构建的班级列表:", classListForDisplay);

        // 设置默认选中第一个班级
        const firstClassId = classListForDisplay.length > 0 ? classListForDisplay[0]._id : null;

        // 更新页面数据
        this.setData({
          classList: classListForDisplay,
          currentClassId: firstClassId,
          classPickerIndex: 0 // 设置picker索引为0
        });
        
        // 加载选中班级的学生列表
        if (firstClassId) {
          await this.loadStudentList(firstClassId);
        }
      } else {
        // 未找到任何班级的处理
        console.log("未找到任何班级");
        this.setData({ 
          classList: [], 
          isLoadingClasses: false,
          currentClassId: null 
        });
      }
    } catch (err) {
      // 错误处理
      console.error("获取班级列表失败", err);
      wx.showToast({ title: '加载班级失败', icon: 'none' });
      this.setData({ classList: [] });
    } finally {
      // 无论成功失败都结束加载状态
      this.setData({ isLoadingClasses: false });
    }
  },

  // 加载指定班级的学生列表
  async loadStudentList(classId) {
    // 参数检查
    if (!classId) return;
    
    // 重置相关数据并设置加载状态
    this.setData({ 
      isLoadingStudents: true, 
      studentsInClass: [], 
      currentStudentId: null, 
      currentStudentName: '', 
      logs: [] 
    });
    
    try {
      // 查询指定班级的学生信息
      console.log(`开始查询班级 ${classId} 的学生`);
      
      // 从users集合中查询该班级的学生
      const studentRes = await db.collection('users').where({
        role: 'student',
        classes: classId  // 使用单值查询，确保能匹配到该班级的学生
      }).field({ _id: true, username: true, dormitory: true }).get();
      
      console.log(`获取到班级 ${classId} 的学生:`, studentRes.data);
      
      // 格式化学生数据，使用username作为姓名，dormitory作为学号
      const formattedStudents = studentRes.data.map(student => ({
        _id: student._id,
        name: student.username || '未知姓名',
        studentId: student.dormitory || '未知学号'
      }));

      console.log(`格式化后的学生数据:`, formattedStudents);

      // 如果有学生，更新页面数据并加载第一个学生的日志
      if (formattedStudents.length > 0) {
        this.setData({
          studentsInClass: formattedStudents,
          currentStudentId: formattedStudents[0]._id,
          currentStudentName: formattedStudents[0].name,
          studentPickerIndex: 0 // 重置学生选择器索引
        });
        
        // 加载第一个学生的谈话日志
        await this.loadLogs(formattedStudents[0]._id);
      } else {
        // 没有学生的处理
        this.setData({
          studentsInClass: [],
          currentStudentId: null,
          currentStudentName: '',
          logs: []
        });
        console.log(`班级 ${classId} 没有学生`);
      }
    } catch (err) {
      // 错误处理
      console.error("获取学生列表失败", err);
      wx.showToast({ title: '加载学生失败', icon: 'none' });
    } finally {
      // 无论成功失败都结束加载状态
      this.setData({ isLoadingStudents: false });
    }
  },

  // 加载指定学生的谈话日志
  async loadLogs(studentId) {
    // 参数检查
    if (!studentId) return;
    
    // 重置日志数据并设置加载状态
    this.setData({ isLoadingLogs: true, logs: [] });
    
    try {
      // 从云数据库查询该学生的谈话日志
      const logRes = await db.collection('counseling_logs').where({
        studentId: studentId,
        // 使用openid限制只查看自己记录的日志
        _openid: this.data.userInfo._openid
      }).orderBy('createTime', 'desc').get();
      
      console.log(`获取到学生 ${studentId} 的谈话日志:`, logRes.data);
      
      // 格式化日志时间显示
      const formattedLogs = logRes.data.map(log => {
        let formattedDate = log.createTime;
        try {
          // 根据时间格式类型进行格式化
          if (typeof log.createTime === 'string') {
            formattedDate = new Date(log.createTime).toLocaleString('zh-CN');
          } else if (log.createTime instanceof Date) {
            formattedDate = log.createTime.toLocaleString('zh-CN');
          }
        } catch (err) {
          // 处理日期格式化错误
          console.warn("日期格式化失败:", err);
        }
        
        // 返回带有格式化时间的日志对象
        return {
          ...log,
          createTimeFormatted: formattedDate
        };
      });
      
      // 更新页面数据
      this.setData({ logs: formattedLogs });
    } catch (err) {
      // 错误处理
      console.error("获取日志失败", err);
      wx.showToast({ title: '加载日志失败', icon: 'none' });
    } finally {
      // 无论成功失败都结束加载状态
      this.setData({ isLoadingLogs: false });
    }
  },

  // 处理班级选择事件
  onClassSelect(e) {
    // 获取被点击的班级ID
    const classId = e.currentTarget.dataset.id;
    console.log('点击班级', classId, '当前选中班级:', this.data.currentClassId);
    
    // 如果选择了不同的班级，则切换
    if (classId && classId !== this.data.currentClassId) {
      console.log('切换到班级:', classId);
      // 显示切换提示
      wx.showToast({
        title: '切换班级',
        icon: 'none',
        duration: 1000
      });
      
      // 找到对应班级的索引值
      const index = this.data.classList.findIndex(item => item._id === classId);
      
      // 更新页面数据
      this.setData({ 
        currentClassId: classId,
        classPickerIndex: index >= 0 ? index : 0
      });
      // 加载新选中班级的学生列表
      this.loadStudentList(classId);
    }
  },

  // 处理学生选择事件
  onStudentSelect(e) {
    // 获取被点击的学生信息
    const studentId = e.currentTarget.dataset.id;
    const studentName = e.currentTarget.dataset.name;
    console.log('点击学生', studentId, studentName, '当前选中学生:', this.data.currentStudentId);
    
    // 如果选择了不同的学生，则切换
    if (studentId && studentId !== this.data.currentStudentId) {
      console.log('切换到学生:', studentName);
      // 显示切换提示
      wx.showToast({
        title: '切换学生',
        icon: 'none',
        duration: 1000
      });
      
      // 找到对应学生的索引值
      const index = this.data.studentsInClass.findIndex(item => item._id === studentId);
      
      // 更新页面数据
      this.setData({ 
        currentStudentId: studentId,
        currentStudentName: studentName,
        studentPickerIndex: index >= 0 ? index : 0
      });
      // 加载新选中学生的谈话日志
      this.loadLogs(studentId);
    }
  },

  // 显示添加日志的模态框
  showAddLogModal() {
    // 检查是否已选中学生
    if (!this.data.currentStudentId) {
      wx.showToast({ title: '请先选择学生', icon: 'none' });
      return;
    }
    // 显示模态框并清空内容
    this.setData({ showAddLogModal: true, newLogContent: '' });
  },

  // 隐藏添加日志的模态框
  hideAddLogModal() {
    this.setData({ showAddLogModal: false });
  },

  // 处理日志内容输入事件
  onLogContentInput(e) {
    // 更新输入的日志内容
    this.setData({ newLogContent: e.detail.value });
  },

  // 提交新的谈话日志
  async submitLog() {
    // 验证日志内容不为空
    if (!this.data.newLogContent.trim()) {
      wx.showToast({ title: '日志内容不能为空', icon: 'none' });
      return;
    }
    // 防止重复提交
    if (this.data.isSubmitting) return;

    // 设置提交状态并显示加载提示
    this.setData({ isSubmitting: true });
    wx.showLoading({ title: '提交中...' });

    try {
      // 获取当前时间用于本地显示
      const now = new Date();
      const formattedDate = now.toLocaleString('zh-CN');
      
      // 向云数据库添加新日志
      const result = await db.collection('counseling_logs').add({
        data: {
          // 自动插入辅导员信息
          counselorId: this.data.userInfo._id,
          counselorName: this.data.userInfo.username || '未知辅导员',
          // 学生和班级信息
          studentId: this.data.currentStudentId,
          studentName: this.data.currentStudentName,
          classId: this.data.currentClassId,
          // 日志内容和创建时间
          content: this.data.newLogContent.trim(),
          createTime: db.serverDate(),
        }
      });
      
      console.log("添加日志成功，结果:", result);
      
      // 隐藏加载提示并显示成功消息
      wx.hideLoading();
      wx.showToast({ title: '添加成功', icon: 'success' });
      this.setData({ showAddLogModal: false });
      
      // 在本地添加新记录，优化用户体验
      const newLog = {
        _id: result._id, // 云数据库返回的新记录ID
        counselorId: this.data.userInfo._id,
        counselorName: this.data.userInfo.username || '未知辅导员',
        studentId: this.data.currentStudentId,
        studentName: this.data.currentStudentName,
        classId: this.data.currentClassId,
        content: this.data.newLogContent.trim(),
        createTime: now,
        createTimeFormatted: formattedDate
      };
      
      // 将新日志添加到列表头部
      this.setData({
        logs: [newLog, ...this.data.logs]
      });
      
      // 可选的重新加载完整日志列表
      // this.loadLogs(this.data.currentStudentId);
    } catch (err) {
      // 错误处理
      wx.hideLoading();
      console.error("添加日志失败", err);
      wx.showToast({ title: '添加失败，请重试', icon: 'none' });
    } finally {
      // 无论成功失败都结束提交状态
      this.setData({ isSubmitting: false });
    }
  },

  // 处理班级下拉选择器变化事件
  onClassPickerChange(e) {
    // 获取选择的索引值
    const index = parseInt(e.detail.value);
    // 验证索引的有效性
    if (index >= 0 && index < this.data.classList.length) {
      // 获取选中的班级信息
      const selectedClass = this.data.classList[index];
      console.log('下拉选择班级:', selectedClass);
      
      // 如果选择了不同的班级，则切换
      if (selectedClass._id !== this.data.currentClassId) {
        // 显示选择提示
        wx.showToast({
          title: '已选择: ' + selectedClass.name,
          icon: 'none',
          duration: 1000
        });
        
        // 更新页面数据
        this.setData({ 
          currentClassId: selectedClass._id,
          classPickerIndex: index
        });
        // 加载新选中班级的学生列表
        this.loadStudentList(selectedClass._id);
      }
    }
  },

  // 处理学生下拉选择器变化事件
  onStudentPickerChange(e) {
    // 获取选择的索引值
    const index = parseInt(e.detail.value);
    // 验证索引的有效性
    if (index >= 0 && index < this.data.studentsInClass.length) {
      // 获取选中的学生信息
      const selectedStudent = this.data.studentsInClass[index];
      console.log('下拉选择学生:', selectedStudent);
      
      // 如果选择了不同的学生，则切换
      if (selectedStudent._id !== this.data.currentStudentId) {
        // 显示选择提示
        wx.showToast({
          title: '已选择: ' + selectedStudent.name,
          icon: 'none',
          duration: 1000
        });
        
        // 更新页面数据
        this.setData({
          currentStudentId: selectedStudent._id,
          currentStudentName: selectedStudent.name,
          studentPickerIndex: index
        });
        // 加载新选中学生的谈话日志
        this.loadLogs(selectedStudent._id);
      }
    }
  },
}); 